/**
  ******************************************************************************
  * @file    sym32l010_hal_gtim.h
  * @author  AE Team
  * @version 1.0.3
  * @date    2024-05-28
  * @brief   Header file of GTIM HAL module.
  *
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2024 SIYIMicro.
  * All rights reserved.</center></h2>
  *
  *
  ******************************************************************************
  */


/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __SYM32L010_HAL_GTIM_H
#define __SYM32L010_HAL_GTIM_H

#ifdef __cplusplus
extern "C" {
#endif


/******************************************************************************/
/* Include files                                                              */
/******************************************************************************/
#include "sym32l010_hal_def.h"


/******************************************************************************/
/* Global type definitions                                                    */
/******************************************************************************/

/* GTIM 计数模式 --------------------------------------------------------------*/
typedef enum
{
    GTIM_COUNTERMODE_UP                 = (0x0UL << GTIMx_CR1_DIR_Pos),         // 递增计数模式
    GTIM_COUNTERMODE_DOWN               = (0x1UL << GTIMx_CR1_DIR_Pos),         // 递减计数模式
    GTIM_COUNTERMODE_CENTERALIGNED1     = (0x1UL << GTIMx_CR1_CMS_Pos),         // 中心对齐模式1
    GTIM_COUNTERMODE_CENTERALIGNED2     = (0x2UL << GTIMx_CR1_CMS_Pos),         // 中心对齐模式2
    GTIM_COUNTERMODE_CENTERALIGNED3     = (0x3UL << GTIMx_CR1_CMS_Pos)          // 中心对齐模式3
} GTIM_CountModeTypeDef;

/* GTIM 滤波时钟分频比 --------------------------------------------------------*/
typedef enum
{
    GTIM_CLOCKDIVISION_DIV1             = (0x0UL << GTIMx_CR1_CKD_Pos),         // fDTS = fPCLK
    GTIM_CLOCKDIVISION_DIV2             = (0x1UL << GTIMx_CR1_CKD_Pos),         // fDTS = fPCLK / 2
    GTIM_CLOCKDIVISION_DIV4             = (0x2UL << GTIMx_CR1_CKD_Pos)          // fDTS = fPCLK / 4
} GTIM_ClockDivisionTypeDef;

/* GTIM 预装载使能控制 --------------------------------------------------------*/
typedef enum
{
    GTIM_AUTORELOAD_PRELOAD_DISABLE     = (0x0UL << GTIMx_CR1_ARPE_Pos),        // 使能预装载
    GTIM_AUTORELOAD_PRELOAD_ENABLE      = (0x1UL << GTIMx_CR1_ARPE_Pos)         // 禁止预装载
} GTIM_AutoReloadPreloadTypeDef;

/* GTIM 通道输出模式 ----------------------------------------------------------*/
typedef enum
{
    GTIM_OCMODE_TIMING                  = (0x0000UL << GTIMx_CCMR1CMP_OC1M_Pos), // 冻结模式
    GTIM_OCMODE_ACTIVE                  = (0x0001UL << GTIMx_CCMR1CMP_OC1M_Pos), // 匹配时置1
    GTIM_OCMODE_INACTIVE                = (0x0002UL << GTIMx_CCMR1CMP_OC1M_Pos), // 匹配时置0
    GTIM_OCMODE_TOGGLE                  = (0x0003UL << GTIMx_CCMR1CMP_OC1M_Pos), // 匹配时翻转
    GTIM_OCMODE_PWM1                    = (0x0006UL << GTIMx_CCMR1CMP_OC1M_Pos), // PWM 模式1
    GTIM_OCMODE_PWM2                    = (0x0007UL << GTIMx_CCMR1CMP_OC1M_Pos), // PWM 模式2
    GTIM_OCMODE_FORCED_ACTIVE           = (0x0005UL << GTIMx_CCMR1CMP_OC1M_Pos), // 强制置1
    GTIM_OCMODE_FORCED_INACTIVE         = (0x0004UL << GTIMx_CCMR1CMP_OC1M_Pos), // 强制清0
    GTIM_OCMODE_RETRIGERRABLE_OPM1      = (0x1000UL << GTIMx_CCMR1CMP_OC1M_Pos), // 可再触发OPM1
    GTIM_OCMODE_RETRIGERRABLE_OPM2      = (0x1001UL << GTIMx_CCMR1CMP_OC1M_Pos), // 可再触发OPM2
    GTIM_OCMODE_COMBINED_PWM1           = (0x1004UL << GTIMx_CCMR1CMP_OC1M_Pos), // 组合 PWM 模式1
    GTIM_OCMODE_COMBINED_PWM2           = (0x1005UL << GTIMx_CCMR1CMP_OC1M_Pos), // 组合 PWM 模式2
    GTIM_OCMODE_ASSYMETRIC_PWM1         = (0x1006UL << GTIMx_CCMR1CMP_OC1M_Pos), // 不对称 PWM 模式1
    GTIM_OCMODE_ASSYMETRIC_PWM2         = (0x1007UL << GTIMx_CCMR1CMP_OC1M_Pos), // 不对称 PWM 模式2
    GTIM_OCMODE_DIRECTION_OUTPUT        = (0x1003UL << GTIMx_CCMR1CMP_OC1M_Pos) // 输出 计数方向
} GTIM_OCModeTypeDef;

/* GTIM 输出比较 输出极性 -----------------------------------------------------*/
typedef enum
{
    GTIM_OCPOLARITY_HIGH                = 0x00000000UL,                         // OCx与OCxDTS同相
    GTIM_OCPOLARITY_LOW                 = GTIMx_CCER_CC1P_Msk                   // OCx与OCxDTS反相
} GTIM_OCPolarityTypeDef;

/* GTIM 输出比较 快速使能 -----------------------------------------------------*/
typedef enum
{
    GTIM_OCFAST_DISABLE                 = 0x00000000UL,                         // 触发启动后OCxREF由OCxM控制
    GTIM_OCFAST_ENABLE                  = GTIMx_CCMR1CMP_OC1FE_Msk              // 触发启动后OCxREF尽快变更匹配后的电平
} GTIM_OCFastModeTypeDef;

/* GTIM 输入极性 --------------------------------------------------------------*/
typedef enum
{
    GTIM_INPUTCHANNELPOLARITY_RISING    = 0x00000000UL,                         // 上升沿触发
    GTIM_INPUTCHANNELPOLARITY_FALLING   = GTIMx_CCER_CC1P_Msk,                  // 下降沿触发
    GTIM_INPUTCHANNELPOLARITY_BOTHEDGE  = (GTIMx_CCER_CC1P_Msk |
                                          GTIMx_CCER_CC1NP_Msk)                 // 双边沿触发
} GTIM_InPutChannelPolarityTypeDef;

/* GTIM 外部触发极性 ----------------------------------------------------------*/
typedef enum
{
    GTIM_ETRPOLARITY_INVERTED           = GTIMx_SMCR_ETP_Msk,                   // 反相，ETR的低电平或下降沿有效
    GTIM_ETRPOLARITY_NONINVERTED        = 0x00000000UL                          // 正相，ETR的高电平或上升沿有效
} GTIM_ETRPolarityTypeDef;

/* GTIM 触发极性 --------------------------------------------------------------*/
typedef enum
{
    GTIM_TRIGGERPOLARITY_INVERTED       = GTIM_ETRPOLARITY_INVERTED,            // ETRx外部触发极性
    GTIM_TRIGGERPOLARITY_NONINVERTED    = GTIM_ETRPOLARITY_NONINVERTED,         // ETRx外部触发极性
    GTIM_TRIGGERPOLARITY_RISING         = GTIM_INPUTCHANNELPOLARITY_RISING,     // TIxFPx 或 TI1FED 触发极性
    GTIM_TRIGGERPOLARITY_FALLING        = GTIM_INPUTCHANNELPOLARITY_FALLING,    // TIxFPx 或 TI1FED 触发极性
    GTIM_TRIGGERPOLARITY_BOTHEDGE       = GTIM_INPUTCHANNELPOLARITY_BOTHEDGE    // TIxFPx 或 TI1FED 触发极性
} GTIM_TriggerPolarityTypeDef;

/* GTIM 输入捕获极性 ----------------------------------------------------------*/
typedef enum
{
    GTIM_ICPOLARITY_RISING              = GTIM_INPUTCHANNELPOLARITY_RISING,     // 上升沿触发输入捕获
    GTIM_ICPOLARITY_FALLING             = GTIM_INPUTCHANNELPOLARITY_FALLING,    // 下降沿触发输入捕获
    GTIM_ICPOLARITY_BOTHEDGE            = GTIM_INPUTCHANNELPOLARITY_BOTHEDGE    // 上升下降都触发输入捕获
} GTIM_ICPolarityTypeDef;

/* GTIM 输入捕获通道选择 ------------------------------------------------------*/
typedef enum
{
    GTIM_ICSELECTION_DIRECTTI           = (0x1UL << GTIMx_CCMR1CAP_CC1S_Pos),   // IC1,IC2,IC3,IC4 映射到
                                                                                // TI1,TI2,TI3,TI4 上
    GTIM_ICSELECTION_INDIRECTTI         = (0x2UL << GTIMx_CCMR1CAP_CC1S_Pos),   // IC1,IC2,IC3,IC4 映射到
                                                                                // TI2,TI1,TI4,TI3 上
    GTIM_ICSELECTION_TRGI               = (0x3UL << GTIMx_CCMR1CAP_CC1S_Pos)    // IC1,IC2,IC3,IC4 映射到TRGI上
} GTIM_ICSelectionTypeDef;

/* GTIM 输入捕获预分频 --------------------------------------------------------*/
typedef enum
{
    GTIM_ICPSC_DIV1                     = 0x00000000UL,                         // 每发生 1 个事件便执行一次捕获
    GTIM_ICPSC_DIV2                     = (0x1UL << GTIMx_CCMR1CAP_IC1PSC_Pos), // 每发生 2 个事件便执行一次捕获
    GTIM_ICPSC_DIV4                     = (0x2UL << GTIMx_CCMR1CAP_IC1PSC_Pos), // 每发生 4 个事件便执行一次捕获
    GTIM_ICPSC_DIV8                     = (0x3UL << GTIMx_CCMR1CAP_IC1PSC_Pos)  // 每发生 8 个事件便执行一次捕获
} GTIM_ICPrescalerTypeDef;

/* GTIM 编码器模式 ------------------------------------------------------------*/
typedef enum
{
    GTIM_ENCODERMODE_TI1                      = (0x00001UL << GTIMx_SMCR_SMS_Pos), // 正交x2模式, 在TI1FP1边沿计数
    GTIM_ENCODERMODE_TI2                      = (0x00002UL << GTIMx_SMCR_SMS_Pos), // 正交x2模式，在TI2FP2边沿计数
    GTIM_ENCODERMODE_TI12                     = (0x00003UL << GTIMx_SMCR_SMS_Pos), // 正交x4模式，在TI1FP1、TI2FP2边沿计数
    GTIM_ENCODERMODE_CLOCKPLUSDIRECTION_X2    = (0x10002UL << GTIMx_SMCR_SMS_Pos), // 方向加脉冲x2模式，在TI2FP2有效边沿计数
    GTIM_ENCODERMODE_CLOCKPLUSDIRECTION_X1    = (0x10003UL << GTIMx_SMCR_SMS_Pos), // 方向加脉冲x1模式，在TI2FP2有效边沿计数
    GTIM_ENCODERMODE_DIRECTIONALCLOCK_X2      = (0x10004UL << GTIMx_SMCR_SMS_Pos), // 具有方向的脉冲x2模式，在TI1FP1、TI2FP2有效边沿计数
    GTIM_ENCODERMODE_DIRECTIONALCLOCK_X1_TI12 = (0x10005UL << GTIMx_SMCR_SMS_Pos), // 具有方向的脉冲x1模式，在TI1FP1、TI2FP2有效边沿计数
    GTIM_ENCODERMODE_X1_TI1                   = (0x10006UL << GTIMx_SMCR_SMS_Pos), // 正交x1模式，在TI1FP1有效边沿计数
    GTIM_ENCODERMODE_X1_TI2                   = (0x10007UL << GTIMx_SMCR_SMS_Pos)  // 正交x1模式，在TI2FP2有效边沿计数
} GTIM_EnCoderModeTypeDef;

/* GTIM 编码器输入极性 --------------------------------------------------------*/
typedef enum
{
    GTIM_ENCODERINPUTPOLARITY_RISING    = GTIM_INPUTCHANNELPOLARITY_RISING,     // 编码器输入极性
    GTIM_ENCODERINPUTPOLARITY_FALLING   = GTIM_INPUTCHANNELPOLARITY_FALLING     // 编码器输入极性
} GTIM_EnCoderPolarityTypeDef;

/* GTIM 触发源选择 ------------------------------------------------------------*/
typedef enum
{
    GTIM_TS_ITR0    = 0x00000000UL,                                                     // 内部触发0  (ITR0: ATIM_TRGO)
    GTIM_TS_ITR1    = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x01UL << GTIMx_SMCR_TS_Pos)), // 内部触发1  (ITR1: None)
    GTIM_TS_ITR2    = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x02UL << GTIMx_SMCR_TS_Pos)), // 内部触发2  (ITR2: None)
    GTIM_TS_ITR3    = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x03UL << GTIMx_SMCR_TS_Pos)), // 内部触发3  (ITR3: None)
    GTIM_TS_TI1F_ED = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x04UL << GTIMx_SMCR_TS_Pos)), // TI1 边沿检测器     (TI1FED)
    GTIM_TS_TI1FP1  = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x05UL << GTIMx_SMCR_TS_Pos)), // 滤波后的定时器输入1 (TI1FP1)
    GTIM_TS_TI2FP2  = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x06UL << GTIMx_SMCR_TS_Pos)), // 滤波后的定时器输入2 (TI2FP2)
    GTIM_TS_ETRF    = ((0x00UL << GTIMx_SMCR_TSH_Pos) | (0x07UL << GTIMx_SMCR_TS_Pos)), // 外部触发输入 (ETRF)
    GTIM_TS_ITR4    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x00UL << GTIMx_SMCR_TS_Pos)), // 内部触发4  (ITR4: None)
    GTIM_TS_ITR5    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x01UL << GTIMx_SMCR_TS_Pos)), // 内部触发5  (ITR5: None)
    GTIM_TS_ITR6    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x02UL << GTIMx_SMCR_TS_Pos)), // 内部触发6  (ITR6: UART1_TXD)
    GTIM_TS_ITR7    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x03UL << GTIMx_SMCR_TS_Pos)), // 内部触发7  (ITR7: UART2_TXD)
    GTIM_TS_ITR8    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x04UL << GTIMx_SMCR_TS_Pos)), // 内部触发8  (ITR8: UART1_RXD)
    GTIM_TS_ITR9    = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x05UL << GTIMx_SMCR_TS_Pos)), // 内部触发9  (ITR9: UART2_RXD)
    GTIM_TS_ITR10   = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x06UL << GTIMx_SMCR_TS_Pos)), // 内部触发10 (ITR10: BTIM1_TRGO)
    GTIM_TS_ITR11   = ((0x01UL << GTIMx_SMCR_TSH_Pos) | (0x07UL << GTIMx_SMCR_TS_Pos)), // 内部触发11 (ITR11: BTIM2_TRGO)
    GTIM_TS_ITR12   = ((0x02UL << GTIMx_SMCR_TSH_Pos) | (0x00UL << GTIMx_SMCR_TS_Pos)), // 内部触发12 (ITR12: BTIM3_TRGO)
    GTIM_TS_NONE    = ((0x03UL << GTIMx_SMCR_TSH_Pos) | (0x07UL << GTIMx_SMCR_TS_Pos))  // 无触发选择
} GTIM_InputTriggerTypeDef;

/* GTIM 计数时钟源 ------------------------------------------------------------*/
typedef enum
{
    GTIM_CLOCKSOURCE_ETRMODE2           = (0x2UL << GTIMx_SMCR_ETPS_Pos),       // 外部时钟源模式2
    GTIM_CLOCKSOURCE_INTERNAL           = (0x1UL << GTIMx_SMCR_ETPS_Pos),       // 内部时钟源模式
    GTIM_CLOCKSOURCE_ITR0               = GTIM_TS_ITR0,                         // 外部时钟源模式1 (ITR0: ATIM_TRGO)
    GTIM_CLOCKSOURCE_ITR1               = GTIM_TS_ITR1,                         // 外部时钟源模式1 (ITR1: None)
    GTIM_CLOCKSOURCE_ITR2               = GTIM_TS_ITR2,                         // 外部时钟源模式1 (ITR2: None)
    GTIM_CLOCKSOURCE_ITR3               = GTIM_TS_ITR3,                         // 外部时钟源模式1 (ITR3: None)
    GTIM_CLOCKSOURCE_TI1ED              = GTIM_TS_TI1F_ED,                      // 外部时钟源模式1 (TI1FED)
    GTIM_CLOCKSOURCE_TI1                = GTIM_TS_TI1FP1,                       // 外部时钟源模式1 (TI1FP1)
    GTIM_CLOCKSOURCE_TI2                = GTIM_TS_TI2FP2,                       // 外部时钟源模式1 (TI2FP2)
    GTIM_CLOCKSOURCE_ETRMODE1           = GTIM_TS_ETRF,                         // 外部时钟源模式1 (ETRF)
    GTIM_CLOCKSOURCE_ITR4               = GTIM_TS_ITR4,                         // 外部时钟源模式1 (ITR4: None)
    GTIM_CLOCKSOURCE_ITR5               = GTIM_TS_ITR5,                         // 外部时钟源模式1 (ITR5: None)
    GTIM_CLOCKSOURCE_ITR6               = GTIM_TS_ITR6,                         // 外部时钟源模式1 (ITR6: UART1_TXD)
    GTIM_CLOCKSOURCE_ITR7               = GTIM_TS_ITR7,                         // 外部时钟源模式1 (ITR7: UART2_TXD)
    GTIM_CLOCKSOURCE_ITR8               = GTIM_TS_ITR8,                         // 外部时钟源模式1 (ITR8: UART1_RXD)
    GTIM_CLOCKSOURCE_ITR9               = GTIM_TS_ITR9,                         // 外部时钟源模式1 (ITR9: UART2_RXD)
    GTIM_CLOCKSOURCE_ITR10              = GTIM_TS_ITR10,                        // 外部时钟源模式1 (ITR10: BTIM1_TRGO)
    GTIM_CLOCKSOURCE_ITR11              = GTIM_TS_ITR11,                        // 外部时钟源模式1 (ITR11: BTIM2_TRGO)
    GTIM_CLOCKSOURCE_ITR12              = GTIM_TS_ITR12                         // 外部时钟源模式1 (ITR12: BTIM3_TRGO)
} GTIM_ClockSourceTypeDef;

/* GTIM 计数时钟极性 --------------------------------------------------------*/
typedef enum
{
    GTIM_CLOCKPOLARITY_INVERTED         = GTIM_ETRPOLARITY_INVERTED,            // ETRx 极性反相
    GTIM_CLOCKPOLARITY_NONINVERTED      = GTIM_ETRPOLARITY_NONINVERTED,         // ETRx 极性不反相
    GTIM_CLOCKPOLARITY_RISING           = GTIM_INPUTCHANNELPOLARITY_RISING,     // ITx 上升沿计数
    GTIM_CLOCKPOLARITY_FALLING          = GTIM_INPUTCHANNELPOLARITY_FALLING,    // ITx 下降沿计数
    GTIM_CLOCKPOLARITY_BOTHEDGE         = GTIM_INPUTCHANNELPOLARITY_BOTHEDGE    // ITx 双边沿计数
} GTIM_ClockPolarityTypeDef;

/* GTIM ETR信号预分频 --------------------------------------------------------*/
typedef enum
{
    GTIM_ETRPRESCALER_DIV1              = 0x00000000UL,                         // fETRP = fETR
    GTIM_ETRPRESCALER_DIV2              = (0x1UL << GTIMx_SMCR_ETPS_Pos),       // fETRP = fETR / 2
    GTIM_ETRPRESCALER_DIV4              = (0x2UL << GTIMx_SMCR_ETPS_Pos),       // fETRP = fETR / 4
    GTIM_ETRPRESCALER_DIV8              = (0x3UL << GTIMx_SMCR_ETPS_Pos)        // fETRP = fETR / 8
} GTIM_ETRPrescalerTypeDef;

/* GTIM 计数时钟预分频 --------------------------------------------------------*/
typedef enum
{
    GTIM_CLOCKPRESCALER_DIV1            = GTIM_ETRPRESCALER_DIV1,               // 不分频
    GTIM_CLOCKPRESCALER_DIV2            = GTIM_ETRPRESCALER_DIV2,               // 2 分频
    GTIM_CLOCKPRESCALER_DIV4            = GTIM_ETRPRESCALER_DIV4,               // 4 分频
    GTIM_CLOCKPRESCALER_DIV8            = GTIM_ETRPRESCALER_DIV8,               // 8 分频
} GTIM_ClockPrescalerTypeDef;

/* GTIM OCREF_CLR信号来源 -----------------------------------------------------*/
typedef enum
{
    GTIM_CLEARINPUTSOURCE_NONE          = 0x7FFFFFFFUL,                         // 禁止OCREF_CLR
    GTIM_CLEARINPUTSOURCE_ETR           = 0x00000001UL,                         // OCREF_CLR = ETRF输入
    GTIM_CLEARINPUTSOURCE_VC1_OUT       = (0x0UL << GTIMx_AF2_OCRSEL_Pos),      // OCREF_CLR = VC1_OUT
    GTIM_CLEARINPUTSOURCE_VC2_OUT       = (0x1UL << GTIMx_AF2_OCRSEL_Pos),      // OCREF_CLR = VC2_OUT
    GTIM_CLEARINPUTSOURCE_ADC_AWD       = (0x4UL << GTIMx_AF2_OCRSEL_Pos)       // OCREF_CLR = ADC_AWD
} GTIM_ClearInputSourceTypeDef;

/* GTIM OCREF清零信号极性 -----------------------------------------------------*/
typedef enum
{
    GTIM_CLEARINPUTPOLARITY_INVERTED    = GTIM_ETRPOLARITY_INVERTED,            // ETRx 管脚极性
    GTIM_CLEARINPUTPOLARITY_NONINVERTED = GTIM_ETRPOLARITY_NONINVERTED,         // ETRx 管脚极性
} GTIM_ClearInputPolarityTypeDef;

/* GTIM OCREF清零信号预分频 ----------------------------------------------------*/
typedef enum
{
    GTIM_CLEARINPUTPRESCALER_DIV1       = GTIM_ETRPRESCALER_DIV1,               // ETR预分频
    GTIM_CLEARINPUTPRESCALER_DIV2       = GTIM_ETRPRESCALER_DIV2,               // ETR预分频
    GTIM_CLEARINPUTPRESCALER_DIV4       = GTIM_ETRPRESCALER_DIV4,               // ETR预分频
    GTIM_CLEARINPUTPRESCALER_DIV8       = GTIM_ETRPRESCALER_DIV8,               // ETR预分频
} GTIM_ClearInputPrescalerTypeDef;

/* GTIM TRGO 选择 ------------------------------------------------------------*/
typedef enum
{
    GTIM_TRGO_RESET       = 0x00000000UL,                                                    // GTIM_EGR.UG 被用作 Trigger Out(TRGO)
    GTIM_TRGO_ENABLE      = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x01UL << GTIMx_CR2_MMS_Pos)), // GTIM_CR1.CEN 位被用作 Trigger Out(TRGO)
    GTIM_TRGO_UPDATE      = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x02UL << GTIMx_CR2_MMS_Pos)), // Update event 被用作 Trigger Out(TRGO)
    GTIM_TRGO_CC1         = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x03UL << GTIMx_CR2_MMS_Pos)), // Capture1 或 compare1 match 1 被用作 Trigger Out(TRGO)
    GTIM_TRGO_CC2         = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x04UL << GTIMx_CR2_MMS_Pos)), // Capture2 或 compare2 match 1 被用作 Trigger Out(TRGO)
    GTIM_TRGO_CC3         = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x05UL << GTIMx_CR2_MMS_Pos)), // Capture3 或 compare3 match 1 被用作 Trigger Out(TRGO)
    GTIM_TRGO_CC4         = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x06UL << GTIMx_CR2_MMS_Pos)), // Capture4 或 compare4 match 1 被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC1REF      = ((0x0UL << GTIMx_CR2_MMSH_Pos) | (0x07UL << GTIMx_CR2_MMS_Pos)), // OC1REF 信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC2REF      = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x00UL << GTIMx_CR2_MMS_Pos)), // OC2REF 信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC3REF      = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x01UL << GTIMx_CR2_MMS_Pos)), // OC3REF 信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC4REF      = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x02UL << GTIMx_CR2_MMS_Pos)), // OC4REF 信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC1REFC     = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x03UL << GTIMx_CR2_MMS_Pos)), // OC1REFC信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC2REFC     = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x04UL << GTIMx_CR2_MMS_Pos)), // OC2REFC信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC3REFC     = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x05UL << GTIMx_CR2_MMS_Pos)), // OC3REFC信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_OC4REFC     = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x06UL << GTIMx_CR2_MMS_Pos)), // OC4REFC信号被用作 Trigger Out(TRGO)
    GTIM_TRGO_ENCODER_CLK = ((0x1UL << GTIMx_CR2_MMSH_Pos) | (0x07UL << GTIMx_CR2_MMS_Pos))  // Encoder clock 被用作 Trigger Out(TRGO)
} GTIM_TrgoSelectionTypeDef;

/* GTIM 主/从模式 ------------------------------------------------------------*/
typedef enum
{
    GTIM_MASTERSLAVEMODE_ENABLE         = GTIMx_SMCR_MSM_Msk,                   // 主/从模式被选中
    GTIM_MASTERSLAVEMODE_DISABLE        = 0x00000000UL                          // 不进行任何操作
} GTIM_MasterSlaveModeTypeDef;

/* GTIM 从模式选择 ------------------------------------------------------------*/
typedef enum
{
    GTIM_SLAVEMODE_DISABLE              = 0x00000000UL,                         // 禁止从模式
    GTIM_SLAVEMODE_RESET                = (0x04UL << GTIMx_SMCR_SMS_Pos),       // 复位模式
    GTIM_SLAVEMODE_GATED                = (0x05UL << GTIMx_SMCR_SMS_Pos),       // 门控模式
    GTIM_SLAVEMODE_TRIGGER              = (0x06UL << GTIMx_SMCR_SMS_Pos),       // 触发模式
    GTIM_SLAVEMODE_EXTERNAL1            = (0x07UL << GTIMx_SMCR_SMS_Pos),       // 外部时钟模式1
    GTIM_SLAVEMODE_COMBINED_RESETTRIGGER= (GTIMx_SMCR_SMSH_Msk | (0x00UL << GTIMx_SMCR_SMS_Pos)), // 组合复位+触发模式
    GTIM_SLAVEMODE_COMBINED_GATEDRESET  = (GTIMx_SMCR_SMSH_Msk | (0x01UL << GTIMx_SMCR_SMS_Pos)), // 组合复位+门控模式
} GTIM_SlaveModeTypeDef;

/* GTIM 从模式触发信号预分频 ---------------------------------------------------*/
typedef enum
{
    GTIM_TRIGGERPRESCALER_DIV1           = GTIM_ETRPRESCALER_DIV1,              // 每 1 次事件触发一次
    GTIM_TRIGGERPRESCALER_DIV2           = GTIM_ETRPRESCALER_DIV2,              // 每 2 次事件触发一次
    GTIM_TRIGGERPRESCALER_DIV4           = GTIM_ETRPRESCALER_DIV4,              // 每 4 次事件触发一次
    GTIM_TRIGGERPRESCALER_DIV8           = GTIM_ETRPRESCALER_DIV8               // 每 8 次事件触发一次
} GTIM_TriggerPrescalerTypeDef;

/* GTIM 编码器索引信号极性 -----------------------------------------------------*/
typedef enum
{
    GTIM_ENCODERINDEX_POLARITY_INVERTED    = GTIM_ETRPOLARITY_INVERTED,         // 编码器索引信号的极性
    GTIM_ENCODERINDEX_POLARITY_NONINVERTED = GTIM_ETRPOLARITY_NONINVERTED       // 编码器索引信号的极性
} GTIM_IndexPolarityTypeDef;

/* GTIM 编码器索引信号预分频 ---------------------------------------------------*/
typedef enum
{
    GTIM_ENCODERINDEX_PRESCALER_DIV1    = GTIM_ETRPRESCALER_DIV1,               // 不分频
    GTIM_ENCODERINDEX_PRESCALER_DIV2    = GTIM_ETRPRESCALER_DIV2,               // 2分频
    GTIM_ENCODERINDEX_PRESCALER_DIV4    = GTIM_ETRPRESCALER_DIV4,               // 4分频
    GTIM_ENCODERINDEX_PRESCALER_DIV8    = GTIM_ETRPRESCALER_DIV8                // 8分频
} GTIM_IndexPrescalerTypeDef;

/* GTIM 编码器索引信号的有效电平(索引位置) -------------------------------------*/
typedef enum
{
    GTIM_ENCODERINDEX_POSITION_00       = 0x00000000UL,                         // 正交编码模式时, 索引位置 AB=00, A = TI1FP1, B = TI2FP2
    GTIM_ENCODERINDEX_POSITION_01       = (0x01UL << GTIMx_ECR_IPOS_Pos),       // 正交编码模式时, 索引位置 AB=01
    GTIM_ENCODERINDEX_POSITION_10       = (0x02UL << GTIMx_ECR_IPOS_Pos),       // 正交编码模式时, 索引位置 AB=10
    GTIM_ENCODERINDEX_POSITION_11       = (0x03UL << GTIMx_ECR_IPOS_Pos),       // 正交编码模式时, 索引位置 AB=11
    GTIM_ENCODERINDEX_POSITION_0        = 0x00000000UL,                         // 方向加脉冲模式时, 时钟低电平时重置计数器
    GTIM_ENCODERINDEX_POSITION_1        = (0x01UL << GTIMx_ECR_IPOS_Pos)        // 方向加脉冲模式时, 时钟高电平时重置计数器
} GTIM_IndexPositionTypeDef;

/* GTIM 编码器索引信号有效方向 -------------------------------------------------*/
typedef enum
{
    GTIM_ENCODERINDEX_DIRECTION_UP_DOWN = 0x00000000UL,                         // 任意方向索引有效
    GTIM_ENCODERINDEX_DIRECTION_UP      = (0x01UL << GTIMx_ECR_IDIR_Pos),       // 仅向上计数时索引有效
    GTIM_ENCODERINDEX_DIRECTION_DOWN    = (0x02UL << GTIMx_ECR_IDIR_Pos)        // 仅向下计数时索引有效
} GTIM_IndexDirectionTypeDef;

/* GTIM 活跃通道 ------------------------------------------------------*/
typedef enum
{
    HAL_GTIM_ACTIVE_CHANNEL_1           = 0x01UL,                               // 活跃的通道为 1
    HAL_GTIM_ACTIVE_CHANNEL_2           = 0x02UL,                               // 活跃的通道为 2
    HAL_GTIM_ACTIVE_CHANNEL_3           = 0x04UL,                               // 活跃的通道为 3
    HAL_GTIM_ACTIVE_CHANNEL_4           = 0x08UL,                               // 活跃的通道为 4
    HAL_GTIM_ACTIVE_CHANNEL_CLEARED     = 0x00UL                                // 清除所有活跃的通道
} HAL_GTIM_ActiveChannel;

/* GTIM 时基初始化结构体 ------------------------------------------------------*/
typedef struct
{
    uint32_t                            Prescaler;                              // 预分频值 0x0000~0xFFFF
    GTIM_CountModeTypeDef               CounterMode;                            // 计数模式
    uint32_t                            Period;                                 // 自动重载值 0x0000~0xFFFF
    GTIM_ClockDivisionTypeDef           ClockDivision;                          // 滤波时钟分频比
    GTIM_AutoReloadPreloadTypeDef       AutoReloadPreload;                      // 自动重载值的预装载功能使能控制
} GTIM_Base_InitTypeDef;

/* GTIM 输出比较 配置结构体 ----------------------------------------------------*/
typedef struct
{
    GTIM_OCModeTypeDef                  OCMode;                                 // GTIM 输出比较的输出模式
    uint32_t                            Pulse;                                  // 向捕获比较寄存器装载的值 0x0000~0xFFFF
    GTIM_OCPolarityTypeDef              OCPolarity;                             // 输出极性
    GTIM_OCFastModeTypeDef              OCFastMode;                             // 输出快速使能控制，仅单脉冲模式适用
} GTIM_OC_InitTypeDef;

/* GTIM 单脉冲模式配置结构体 ---------------------------------------------------*/
typedef struct
{
    GTIM_OCModeTypeDef                  OCMode;                                 // GTIM 输出比较的输出模式
    uint32_t                            Pulse;                                  // 脉冲宽度 向捕获比较寄存器装载的值 0x0000~0xFFFF
    GTIM_OCPolarityTypeDef              OCPolarity;                             // 输出极性
    GTIM_ICPolarityTypeDef              ICPolarity;                             // 输入捕获信号极性
    GTIM_ICSelectionTypeDef             ICSelection;                            // 输入捕获通道选择
    uint32_t                            ICFilter;                               // 输入捕获信号滤波参数 0x0~0xF
} GTIM_OnePulse_InitTypeDef;

/* GTIM 输入捕获配置结构体 -----------------------------------------------------*/
typedef struct
{
    GTIM_ICPolarityTypeDef              ICPolarity;                             // 输入捕获信号极性
    GTIM_ICSelectionTypeDef             ICSelection;                            // 输入捕获通道选择
    GTIM_ICPrescalerTypeDef             ICPrescaler;                            // 输入捕获信号预分频
    uint32_t                            ICFilter;                               // 输入捕获信号滤波参数 0x0~0xF
} GTIM_IC_InitTypeDef;

/* GTIM 编码器配置结构体 ------------------------------------------------------*/
typedef struct
{
    GTIM_EnCoderModeTypeDef             EncoderMode;                            // 编码器模式

    GTIM_EnCoderPolarityTypeDef         IC1Polarity;                            // 通道极性
    GTIM_ICSelectionTypeDef             IC1Selection;                           // 通道选择
    GTIM_ICPrescalerTypeDef             IC1Prescaler;                           // 捕获预分频
    uint32_t                            IC1Filter;                              // 滤波参数

    GTIM_EnCoderPolarityTypeDef         IC2Polarity;                            // 通道极性
    GTIM_ICSelectionTypeDef             IC2Selection;                           // 通道选择
    GTIM_ICPrescalerTypeDef             IC2Prescaler;                           // 捕获预分频
    uint32_t                            IC2Filter;                              // 滤波参数
} GTIM_Encoder_InitTypeDef;

/* GTIM 计数时钟配置结构体 -----------------------------------------------------*/
typedef struct
{
    GTIM_ClockSourceTypeDef             ClockSource;                            // GTIM 计数时钟源
    GTIM_ClockPolarityTypeDef           ClockPolarity;                          // GTIM 计数时钟极性
    GTIM_ClockPrescalerTypeDef          ClockPrescaler;                         // GTIM 计数时钟预分频
    uint32_t                            ClockFilter;                            // 计数时钟滤波参数
} GTIM_ClockConfigTypeDef;

/* GTIM 清零输入配置结构体 -----------------------------------------------------*/
typedef struct
{
    FunctionalState                     ClearInputState;                        // OCREF_CLR 输入使能状态 ENABLE / DISABLE
    GTIM_ClearInputSourceTypeDef        ClearInputSource;                       // OCREF_CLR 输入信号来源
    GTIM_ClearInputPolarityTypeDef      ClearInputPolarity;                     // OCREF_CLR 输入极性
    GTIM_ClearInputPrescalerTypeDef     ClearInputPrescaler;                    // OCREF_CLR信号预分频
    uint32_t                            ClearInputFilter;                       // OCREF_CLR信号滤波参数 0x0~0xF
} GTIM_ClearInputConfigTypeDef;

/* GTIM 主模式配置结构体 ------------------------------------------------------*/
typedef struct
{
    GTIM_TrgoSelectionTypeDef           MasterOutputTrigger;                    // Trigger output (TRGO) 信号选择
    GTIM_MasterSlaveModeTypeDef         MasterSlaveMode;                        // 主从模式配置
} GTIM_MasterConfigTypeDef;

/* GTIM 从模式配置结构体 ------------------------------------------------------*/
typedef struct
{
    GTIM_SlaveModeTypeDef               SlaveMode;                              // 从模式选择
    GTIM_InputTriggerTypeDef            InputTrigger;                           // 输入触发源
    GTIM_TriggerPolarityTypeDef         TriggerPolarity;                        // 触发极性
    GTIM_TriggerPrescalerTypeDef        TriggerPrescaler;                       // 输入触发预分频
    uint32_t                            TriggerFilter;                          // 输入触发滤波参数 0x0~0xF
} GTIM_SlaveConfigTypeDef;

/* GTIM 霍尔传感器配置结构体 ---------------------------------------------------*/
typedef struct
{
    GTIM_ICPolarityTypeDef              IC1Polarity;                            // 输入捕获信号极性
    GTIM_ICPrescalerTypeDef             IC1Prescaler;                           // 输入捕获信号预分频
    uint32_t                            IC1Filter;                              // 输入捕获信号滤波参数
    uint32_t                            Commutation_Delay;                      // 脉冲宽度 向捕获比较寄存器装载的值 0x0000~0xFFFF
} GTIM_HallSensor_InitTypeDef;

/* GTIM 编码器索引信号配置结构体 -----------------------------------------------*/
typedef struct
{
    GTIM_IndexPolarityTypeDef           Polarity;                               // GTIM 编码器索引信号极性配置
    GTIM_IndexPrescalerTypeDef          Prescaler;                              // GTIM 编码器索引信号预分频配置
    uint32_t                            Filter;                                 // GTIM 编码器索引信号滤波参数
    FunctionalState                     FirstIndexEnable;                       // GTIM 编码器是否只执行首次索引信号,忽略后续索引信号
    GTIM_IndexPositionTypeDef           Position;                               // GTIM 编码器索引位置配置
    GTIM_IndexDirectionTypeDef          Direction;                              // GTIM 编码器索引信号有效计数方向配置
} GTIM_EncoderIndexConfigTypeDef;

 /* GTIM 初始化配置句柄类型 ---------------------------------------------------*/
typedef struct
{
    GTIM_TypeDef                        *Instance;                              // GTIM 基地址
    GTIM_Base_InitTypeDef               Init;                                   // GTIM 时基初始化
    GTIM_OC_InitTypeDef                 OcInit;                                 // GTIM 输出比较初始化
    GTIM_IC_InitTypeDef                 IcInit;                                 // GTIM 输入捕获初始化
    HAL_GTIM_ActiveChannel              Channel;                                // 活跃通道
} GTIM_HandleTypeDef;


/******************************************************************************/
/* Global pre-processor symbols/macros ('#define')                            */
/******************************************************************************/
/** @defgroup GTIM_Channel GTIM Channel */
#define GTIM_CHANNEL_1                  0x00000001UL                            // 捕获/比较通道1
#define GTIM_CHANNEL_2                  0x00000010UL                            // 捕获/比较通道2
#define GTIM_CHANNEL_3                  0x00000100UL                            // 捕获/比较通道3
#define GTIM_CHANNEL_4                  0x00001000UL                            // 捕获/比较通道4
#define GTIM_CHANNEL_ALL                0x00001111UL                            // 所有捕获/比较通道

/*********** GTIM Instances : Slave mode available (TIMx_SMCR available )*******/
#define GTIM_CR2_MMS                    (GTIMx_CR2_MMS_Msk | GTIMx_CR2_MMSH_Msk)
#define GTIM_SMCR_TS                    (GTIMx_SMCR_TS_Msk  | GTIMx_SMCR_TSH_Msk)
#define GTIM_SMCR_SMS                   (GTIMx_SMCR_SMS_Msk | GTIMx_SMCR_SMSH_Msk)
#define GTIM_CCMR1CMP_OC1M              (GTIMx_CCMR1CMP_OC1M_Msk | GTIMx_CCMR1CMP_OC1MH_Msk)
#define GTIM_CCMR1CMP_OC2M              (GTIMx_CCMR1CMP_OC2M_Msk | GTIMx_CCMR1CMP_OC2MH_Msk)
#define GTIM_CCMR2CMP_OC3M              (GTIMx_CCMR2CMP_OC3M_Msk | GTIMx_CCMR2CMP_OC3MH_Msk)
#define GTIM_CCMR2CMP_OC4M              (GTIMx_CCMR2CMP_OC4M_Msk | GTIMx_CCMR2CMP_OC4MH_Msk)

#define GTIM_CCER_CCxE_MASK  ((uint32_t)(GTIMx_CCER_CC1E_Msk | GTIMx_CCER_CC2E_Msk | \
                                         GTIMx_CCER_CC3E_Msk | GTIMx_CCER_CC4E_Msk))

/** @defgroup GTIM_Event_Source GTIM Event Source */
#define GTIM_EVENTSOURCE_UPDATE         GTIMx_EGR_UG_Msk                        // 重新初始化计数器并产生一个更新事件更新寄存器
#define GTIM_EVENTSOURCE_CC1            GTIMx_EGR_CC1G_Msk                      // 在CH1上产生一个 捕获/比较 事件
#define GTIM_EVENTSOURCE_CC2            GTIMx_EGR_CC2G_Msk                      // 在CH2上产生一个 捕获/比较 事件
#define GTIM_EVENTSOURCE_CC3            GTIMx_EGR_CC3G_Msk                      // 在CH3上产生一个 捕获/比较 事件
#define GTIM_EVENTSOURCE_CC4            GTIMx_EGR_CC4G_Msk                      // 在CH4上产生一个 捕获/比较 事件
#define GTIM_EVENTSOURCE_TRIGGER        GTIMx_EGR_TG_Msk                        // 产生一个 Trigger 事件

/** @defgroup GTIM_Update_Interrupt_Flag_Remap GTIM Update Interrupt Flag Remap */
#define GTIM_UIFREMAP_DISABLE           0x00000000UL                            // 禁止更新中断标志重映射
#define GTIM_UIFREMAP_ENABLE            GTIMx_CR1_UIFREMAP_Msk                  // 使能更新中断标志重映射

/** @defgroup GTIM_Output_Compare_State GTIM Output Compare State */
#define GTIM_OUTPUTSTATE_DISABLE        0x00000000UL                            // GTIM输出比较状态 Disable
#define GTIM_OUTPUTSTATE_ENABLE         GTIMx_CCER_CC1E_Msk                     // GTIM输出比较状态 Enable

/** @defgroup GTIM_One_Pulse_Mode GTIM One Pulse Mode */
#define GTIM_OPMODE_SINGLE              GTIMx_CR1_OPM_Msk                       // 在下次发生更新事件时, 计数器停止计数
#define GTIM_OPMODE_REPETITIVE          0x00000000UL                            // 在下次发生更新事件时, 计数器不停止

/** @defgroup GTIM_Interrupt_definition GTIM interrupt Definition */
#define GTIM_IT_SOURCE_UPDATE           GTIMx_DIER_UIE_Msk                      // GTIM 更新中断 (Update/UIE)
#define GTIM_IT_SOURCE_CC1              GTIMx_DIER_CC1IE_Msk                    // GTIM 捕获/比较1 中断
#define GTIM_IT_SOURCE_CC2              GTIMx_DIER_CC2IE_Msk                    // GTIM 捕获/比较2 中断
#define GTIM_IT_SOURCE_CC3              GTIMx_DIER_CC3IE_Msk                    // GTIM 捕获/比较3 中断
#define GTIM_IT_SOURCE_CC4              GTIMx_DIER_CC4IE_Msk                    // GTIM 捕获/比较4 中断
#define GTIM_IT_SOURCE_TRIGGER          GTIMx_DIER_TIE_Msk                      // GTIM Trigger 中断
#define GTIM_IT_SOURCE_IDX              GTIMx_DIER_IDXIE_Msk                    // GTIM Index 中断
#define GTIM_IT_SOURCE_DIR              GTIMx_DIER_DIRIE_Msk                    // GTIM 方向改变 中断
#define GTIM_IT_SOURCE_IERR             GTIMx_DIER_IERRIE_Msk                   // GTIM 编码器错误 中断
#define GTIM_IT_SOURCE_TERR             GTIMx_DIER_TERRIE_Msk                   // GTIM 正交编码转换 错误

/** @defgroup GTIM_IT_Flag_definition GTIM Flag Definition */
#define GTIM_IT_FLAG_UPDATE             GTIMx_ISR_UIF_Msk                       // 更新事件 标志
#define GTIM_IT_FLAG_CC1                GTIMx_ISR_CC1IF_Msk                     // 捕获/比较1 标志
#define GTIM_IT_FLAG_CC2                GTIMx_ISR_CC2IF_Msk                     // 捕获/比较2 标志
#define GTIM_IT_FLAG_CC3                GTIMx_ISR_CC3IF_Msk                     // 捕获/比较3 标志
#define GTIM_IT_FLAG_CC4                GTIMx_ISR_CC4IF_Msk                     // 捕获/比较4 标志
#define GTIM_IT_FLAG_TRIGGER            GTIMx_ISR_TIF_Msk                       // Trigger 触发标志
#define GTIM_IT_FLAG_IDX                GTIMx_ISR_IDXF_Msk                      // 编码计数索引 标志
#define GTIM_IT_FLAG_DIR                GTIMx_ISR_DIRF_Msk                      // 编码计数方向改变 标志
#define GTIM_IT_FLAG_IERR               GTIMx_ISR_IERRF_Msk                     // 编码计数索引错误 标志
#define GTIM_IT_FLAG_TERR               GTIMx_ISR_TERRF_Msk                     // 正交编码转换错误 标志

/** @defgroup GTIM_Flag_definition GTIM Flag Definition */
#define GTIM_FLAG_UPDATE                GTIMx_ISR_UIF_Msk                       // 更新事件 标志
#define GTIM_FLAG_CC1                   GTIMx_ISR_CC1IF_Msk                     // 捕获/比较1 标志
#define GTIM_FLAG_CC2                   GTIMx_ISR_CC2IF_Msk                     // 捕获/比较2 标志
#define GTIM_FLAG_CC3                   GTIMx_ISR_CC3IF_Msk                     // 捕获/比较3 标志
#define GTIM_FLAG_CC4                   GTIMx_ISR_CC4IF_Msk                     // 捕获/比较4 标志
#define GTIM_FLAG_TRIGGER               GTIMx_ISR_TIF_Msk                       // Trigger 触发标志
#define GTIM_FLAG_IDX                   GTIMx_ISR_IDXF_Msk                      // 编码计数索引 标志
#define GTIM_FLAG_DIR                   GTIMx_ISR_DIRF_Msk                      // 编码计数方向改变 标志
#define GTIM_FLAG_IERR                  GTIMx_ISR_IERRF_Msk                     // 编码计数索引错误 标志
#define GTIM_FLAG_TERR                  GTIMx_ISR_TERRF_Msk                     // 正交编码转换错误 标志
#define GTIM_FLAG_CC1OF                 GTIMx_ISR_CC1OF_Msk                     // 捕获1 重复捕获 标志
#define GTIM_FLAG_CC2OF                 GTIMx_ISR_CC2OF_Msk                     // 捕获2 重复捕获 标志
#define GTIM_FLAG_CC3OF                 GTIMx_ISR_CC3OF_Msk                     // 捕获3 重复捕获 标志
#define GTIM_FLAG_CC4OF                 GTIMx_ISR_CC4OF_Msk                     // 捕获4 重复捕获 标志

/** @defgroup GTIM_TI1_Selection GTIM TI1 Input Selection */
#define GTIM_TI1SELECTION_CH1            0x00000000UL                           // TI1 = GTIM_CH1 管脚
#define GTIM_TI1SELECTION_XORCOMBINATION GTIMx_CR2_TI1S_Msk                     // TI1 = GTIM_CH1 ^ GTIM_CH2 ^ GTIM_CH1 (三通道异或)

/** @defgroup Channel_CC_State GTIM Capture/Compare Channel State */
#define GTIM_CCx_ENABLE                 0x00000001UL                            // CC1输入或输出通道 使能
#define GTIM_CCx_DISABLE                0x00000000UL                            // CC1输入或输出通道 禁止

/** @defgroup GTIM_Remap GTIM Extended Remapping */
#define GTIM_ETRSEL_GPIO                0x00000000UL                            // ETR 管脚 作为ETR信号来源
#define GTIM_ETRSEL_VC1_OUT             (0x1 << GTIMx_AF1_ETRSEL_Pos)           // VC1_OUT 作为ETR信号来源
#define GTIM_ETRSEL_VC2_OUT             (0x2 << GTIMx_AF1_ETRSEL_Pos)           // VC2_OUT 作为ETR信号来源
#define GTIM_ETRSEL_ADC_AWD             (0x5 << GTIMx_AF1_ETRSEL_Pos)           // ADC_AWD 作为ETR信号来源
#define GTIM_ETRSEL_HSE_FAULT           (0x7 << GTIMx_AF1_ETRSEL_Pos)           // HSE_FAULT 作为ETR信号来源
#define GTIM_ETRSEL_LVD_OUT             (0x8 << GTIMx_AF1_ETRSEL_Pos)           // LVD_OUT 作为ETR信号来源
#define GTIM_ETRSEL_UART1_TXD           (0xD << GTIMx_AF1_ETRSEL_Pos)           // UART1_TXD 作为ETR信号来源
#define GTIM_ETRSEL_UART2_TXD           (0xE << GTIMx_AF1_ETRSEL_Pos)           // UART2_TXD 作为ETR信号来源
#define GTIM_ETRSEL_LSE_FAULT           (0xF << GTIMx_AF1_ETRSEL_Pos)           // LSE_FAULT 作为ETR信号来源

/** @defgroup GTIM_Timer_Input_Selection GTIM Extended Timer input selection */
#define GTIM_TIxSEL_GPIO                0x00000000UL                            // GPIO 作为CHx输入捕获来源
#define GTIM_TIxSEL_VC1_OUT             (0x1 << GTIMx_TISEL_TI1SEL_Pos)         // VC1_OUT 作为CHx输入捕获来源
#define GTIM_TIxSEL_VC2_OUT             (0x2 << GTIMx_TISEL_TI1SEL_Pos)         // VC2_OUT 作为CHx输入捕获来源
#define GTIM_TIxSEL_UART1_RXD           (0x3 << GTIMx_TISEL_TI1SEL_Pos)         // UART1_RXD 作为CHx输入捕获来源
#define GTIM_TIxSEL_UART2_RXD           (0x4 << GTIMx_TISEL_TI1SEL_Pos)         // UART2_RXD 作为CHx输入捕获来源
#define GTIM_TIxSEL_MCO_OUT             (0x5 << GTIMx_TISEL_TI1SEL_Pos)         // MCO_OUT 作为CHx输入捕获来源
#define GTIM_TIxSEL_HSE_FAULT           (0x6 << GTIMx_TISEL_TI1SEL_Pos)         // HSE_FAULT 作为CHx输入捕获来源
#define GTIM_TIxSEL_LSE_FAULT           (0x7 << GTIMx_TISEL_TI1SEL_Pos)         // LSE_FAULT 作为CHx输入捕获来源
#define GTIM_TIxSEL_RTC_OUT             (0x8 << GTIMx_TISEL_TI1SEL_Pos)         // RTC_OUT 作为CHx输入捕获来源
#define GTIM_TIxSEL_LSI_OUT             (0x9 << GTIMx_TISEL_TI1SEL_Pos)         // LSI_OUT 作为CHx输入捕获来源
#define GTIM_TIxSEL_BTIM1_TRGO          (0xA << GTIMx_TISEL_TI1SEL_Pos)         // BTIM1_Trgo 作为CHx输入捕获来源
#define GTIM_TIxSEL_BTIM2_TRGO          (0xB << GTIMx_TISEL_TI1SEL_Pos)         // BTIM2_Trgo 作为CHx输入捕获来源
#define GTIM_TIxSEL_BTIM3_TRGO          (0xC << GTIMx_TISEL_TI1SEL_Pos)         // BTIM3_Trgo 作为CHx输入捕获来源
#define GTIM_TIxSEL_ATIM_TRGO           (0xF << GTIMx_TISEL_TI1SEL_Pos)         // ATIM_Trgo 作为CHx输入捕获来源

/** @defgroup GTIM_SMS_Preload_Enable GTIM Extended Bitfield SMS preload enabling */
#define GTIM_SMS_PRELOAD_SOURCE_UPDATE  0x00000000UL                            // 发生更新事件时更新SMS的影子寄存器
#define GTIM_SMS_PRELOAD_SOURCE_INDEX   GTIMx_SMCR_SMSPS_Msk                    // 发生索引事件时更新SMS的影子寄存器

/******************************************************************************/
/* Global macro function                                                      */
/******************************************************************************/
/**
  * @brief  使能 GTIM 外设
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval None
  */
#define HAL_GTIM_ENABLE(__HANDLE__)    ((__HANDLE__)->Instance->CR1 |= (GTIMx_CR1_CEN_Msk))

/**
  * @brief  禁止 GTIM 外设
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval None
  */
#define HAL_GTIM_DISABLE(__HANDLE__)                                     \
    do {                                                                 \
        if (((__HANDLE__)->Instance->CCER & GTIM_CCER_CCxE_MASK) == 0UL) \
        {                                                                \
            (__HANDLE__)->Instance->CR1 &= ~(GTIMx_CR1_CEN_Msk);         \
        }                                                                \
  } while (0)

/**
  * @brief  检查指定的 GTIM 中断源是否被使能
  * @param  __HANDLE__    GTIM 句柄指针
  * @param  __INTERRUPT__ 指定要检查的 GTIM 中断源，该参数可为下列之一:
  *             @arg GTIM_IT_SOURCE_UPDATE:  更新中断 (Update/UIE)
  *             @arg GTIM_IT_SOURCE_CC1:     捕获/比较1 中断
  *             @arg GTIM_IT_SOURCE_CC2:     捕获/比较2 中断
  *             @arg GTIM_IT_SOURCE_CC3:     捕获/比较3 中断
  *             @arg GTIM_IT_SOURCE_CC4:     捕获/比较4 中断
  *             @arg GTIM_IT_SOURCE_TRIGGER: Trigger 中断
  *             @arg GTIM_IT_SOURCE_IDX:     Index 中断
  *             @arg GTIM_IT_SOURCE_DIR:     方向改变 中断
  *             @arg GTIM_IT_SOURCE_IERR:    编码器计数索引错误 中断
  *             @arg GTIM_IT_SOURCE_TERR:    正交编码转换错误 中断
  * @retval 中断源状态 (SET or RESET).
  */
#define HAL_GTIM_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__)    ((((__HANDLE__)->Instance->DIER & (__INTERRUPT__)) \
                                                              == (__INTERRUPT__)) ? SET : RESET)

/**
  * @brief  使能指定的 GTIM 中断
  * @param  __HANDLE__    GTIM 句柄指针
  * @param  __INTERRUPT__ 指定要使能的 GTIM 中断源，该参数可为下列之一:
  *             @arg GTIM_IT_SOURCE_UPDATE:  更新中断 (Update/UIE)
  *             @arg GTIM_IT_SOURCE_CC1:     捕获/比较1 中断
  *             @arg GTIM_IT_SOURCE_CC2:     捕获/比较2 中断
  *             @arg GTIM_IT_SOURCE_CC3:     捕获/比较3 中断
  *             @arg GTIM_IT_SOURCE_CC4:     捕获/比较4 中断
  *             @arg GTIM_IT_SOURCE_TRIGGER: Trigger 中断
  *             @arg GTIM_IT_SOURCE_IDX:     Index 中断
  *             @arg GTIM_IT_SOURCE_DIR:     方向改变 中断
  *             @arg GTIM_IT_SOURCE_IERR:    编码器计数索引错误 中断
  *             @arg GTIM_IT_SOURCE_TERR:    正交编码转换错误 中断
  * @retval None
  */
#define HAL_GTIM_ENABLE_IT(__HANDLE__, __INTERRUPT__)    ((__HANDLE__)->Instance->DIER |= (__INTERRUPT__))

/**
  * @brief  禁止指定的 GTIM 中断源
  * @param  __HANDLE__    GTIM 句柄指针
  * @param  __INTERRUPT__ 指定要禁止的 GTIM 中断源，该参数可为下列之一:
  *             @arg GTIM_IT_SOURCE_UPDATE:  更新中断 (Update/UIE)
  *             @arg GTIM_IT_SOURCE_CC1:     捕获/比较1 中断
  *             @arg GTIM_IT_SOURCE_CC2:     捕获/比较2 中断
  *             @arg GTIM_IT_SOURCE_CC3:     捕获/比较3 中断
  *             @arg GTIM_IT_SOURCE_CC4:     捕获/比较4 中断
  *             @arg GTIM_IT_SOURCE_TRIGGER: Trigger 中断
  *             @arg GTIM_IT_SOURCE_IDX:     Index 中断
  *             @arg GTIM_IT_SOURCE_DIR:     方向改变 中断
  *             @arg GTIM_IT_SOURCE_IERR:    编码器计数索引错误 中断
  *             @arg GTIM_IT_SOURCE_TERR:    正交编码转换错误 中断
  * @retval None
  */
#define HAL_GTIM_DISABLE_IT(__HANDLE__, __INTERRUPT__)    ((__HANDLE__)->Instance->DIER &= ~(__INTERRUPT__))
#define HAL_GTIM_CLEAR_IT  HAL_GTIM_DISABLE_IT

/**
  * @brief  检查指定的 GTIM 中断标志
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __FLAG__   指定要检查的 GTIM 中断标志，该参数可为下列之一:
  *             @arg GTIM_FLAG_UPDATE:       更新事件 标志
  *             @arg GTIM_FLAG_CC1:          捕获/比较1 标志
  *             @arg GTIM_FLAG_CC2:          捕获/比较2 标志
  *             @arg GTIM_FLAG_CC3:          捕获/比较3 标志
  *             @arg GTIM_FLAG_CC4:          捕获/比较4 标志
  *             @arg GTIM_FLAG_TRIGGER:      Trigger 触发标志
  *             @arg GTIM_FLAG_CC1OF:        捕获1 重复捕获 标志
  *             @arg GTIM_FLAG_CC2OF:        捕获2 重复捕获 标志
  *             @arg GTIM_FLAG_CC3OF:        捕获3 重复捕获 标志
  *             @arg GTIM_FLAG_CC4OF:        捕获4 重复捕获 标志
  *             @arg GTIM_FLAG_IDX:          编码计数索引 标志
  *             @arg GTIM_FLAG_DIR:          编码计数方向改变 标志
  *             @arg GTIM_FLAG_IERR:         编码计数索引错误 标志
  *             @arg GTIM_FLAG_TERR:         正交编码转换错误 标志
  * @retval 中断标志状态 (TRUE or FALSE).
  */
#define HAL_GTIM_GET_FLAG(__HANDLE__, __FLAG__)    (((__HANDLE__)->Instance->ISR &(__FLAG__)) == (__FLAG__))

/**
  * @brief  清除指定的 GTIM 中断标志
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __FLAG__   指定要清除的 GTIM 中断标志，该参数可为下列之一:
  *             @arg GTIM_FLAG_UPDATE:       更新事件 标志
  *             @arg GTIM_FLAG_CC1:          捕获/比较1 标志
  *             @arg GTIM_FLAG_CC2:          捕获/比较2 标志
  *             @arg GTIM_FLAG_CC3:          捕获/比较3 标志
  *             @arg GTIM_FLAG_CC4:          捕获/比较4 标志
  *             @arg GTIM_FLAG_TRIGGER:      Trigger 触发标志
  *             @arg GTIM_FLAG_CC1OF:        捕获1 重复捕获 标志
  *             @arg GTIM_FLAG_CC2OF:        捕获2 重复捕获 标志
  *             @arg GTIM_FLAG_CC3OF:        捕获3 重复捕获 标志
  *             @arg GTIM_FLAG_CC4OF:        捕获4 重复捕获 标志
  *             @arg GTIM_FLAG_IDX:          编码计数索引 标志
  *             @arg GTIM_FLAG_DIR:          编码计数方向改变 标志
  *             @arg GTIM_FLAG_IERR:         编码计数索引错误 标志
  *             @arg GTIM_FLAG_TERR:         正交编码转换错误 标志
  * @retval None
  */
#define HAL_GTIM_CLEAR_FLAG(__HANDLE__, __FLAG__)    ((__HANDLE__)->Instance->ICR = ~(__FLAG__))
#define HAL_GTIM_CLR_FLAG  HAL_GTIM_CLEAR_FLAG

/**
  * @brief  将更新中断标志(UIF)复制到定时器计数器寄存器(位31)
  * @note   用户通过一次读操作即可同时获取计数值CNT以及更新标志ISR.UIF
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval None
  */
#define HAL_GTIM_UIFREMAP_ENABLE(__HANDLE__)    (((__HANDLE__)->Instance->CR1 |= GTIMx_CR1_UIFREMAP_Msk))

/**
  * @brief  禁用更新中断标志(UIF)重映射
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval None
  */
#define HAL_GTIM_UIFREMAP_DISABLE(__HANDLE__)    (((__HANDLE__)->Instance->CR1 &= ~GTIMx_CR1_UIFREMAP_Msk))

/**
  * @brief  获取UIFCPY的状态
  * @param  __COUNTER__ GTIM_CNT 寄存器值
  * @retval UIFCPY的状态 (TRUE or FALSE)
  */
#define HAL_GTIM_GET_UIFCPY(__COUNTER__)    (((__COUNTER__) & (GTIMx_CNT_UIFCPY_Msk)) == (GTIMx_CNT_UIFCPY_Msk))

/**
  * @brief  指示当前是否将GTIM计数器用作downcounter
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval False (Counter 加计数) 或 True (Counter 减计数)
  * @note   当定时器以中心对齐模式或编码器工作时, 这个宏对于获取计数方向特别有用
  */
#define HAL_GTIM_IS_TIM_COUNTING_DOWN(__HANDLE__)    (((__HANDLE__)->Instance->CR1 & (GTIMx_CR1_DIR_Msk)) == (GTIMx_CR1_DIR_Msk))

/**
  * @brief  在 GTIM 运行时设置预分频寄存器(GTIM_PSC)
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __PRESC__  指定新的预分频值
  * @retval None
  */
#define HAL_GTIM_SET_PRESCALER(__HANDLE__, __PRESC__)    ((__HANDLE__)->Instance->PSC = (__PRESC__))

/**
  * @brief  在 GTIM 运行时设置计数值寄存器(GTIM_CNT)
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __COUNTER__ 指定新的CNT值
  * @retval None
  */
#define HAL_GTIM_SET_COUNTER(__HANDLE__, __COUNTER__)    ((__HANDLE__)->Instance->CNT = (__COUNTER__))

/**
  * @brief  在 GTIM 运行时获取 GTIM_CNT 值
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval 16 bit 定时器计数器的计数值
  */
#define HAL_GTIM_GET_COUNTER(__HANDLE__)    ((__HANDLE__)->Instance->CNT)

/**
  * @brief  在 GTIM 运行时设置 GTIM_ARR 寄存器值，而无需再次调用任何Init函数
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __AUTORELOAD__ 指定新的 GTIM_ARR 值
  * @retval None
  */
#define HAL_GTIM_SET_AUTORELOAD(__HANDLE__, __AUTORELOAD__) \
    do                                                      \
        (__HANDLE__)->Instance->ARR = (__AUTORELOAD__);     \
        (__HANDLE__)->Init.Period = (__AUTORELOAD__);       \
    } while (0)

/**
  * @brief  在 GTIM 运行时获取 GTIM_ARR 寄存器值
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval 16-bit 定时器自动装载寄存器的值
  */
#define HAL_GTIM_GET_AUTORELOAD(__HANDLE__)    ((__HANDLE__)->Instance->ARR)

/**
  * @brief  在 GTIM 运行时设置滤波时钟分频比，而无需再调用任何Init函数
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __CKD__    指定滤波时钟分频比，该参数可为下列之一:
  *             @arg GTIM_CLOCKDIVISION_DIV1: fDTS = fPCLK
  *             @arg GTIM_CLOCKDIVISION_DIV2: fDTS = fPCLK / 2
  *             @arg GTIM_CLOCKDIVISION_DIV4: fDTS = fPCLK / 4
  * @retval None
  */
#define HAL_GTIM_SET_CLOCKDIVISION(__HANDLE__, __CKD__)      \
    do {                                                     \
        (__HANDLE__)->Instance->CR1 &= (~GTIMx_CR1_CKD_Msk); \
        (__HANDLE__)->Instance->CR1 |= (__CKD__);            \
        (__HANDLE__)->Init.ClockDivision = (__CKD__);        \
    } while (0)

/**
  * @brief  在 GTIM 运行时获取滤波时钟分频比
  * @param  __HANDLE__ GTIM 句柄指针
  * @retval 该返回值为下列之一:
  *             @arg GTIM_CLOCKDIVISION_DIV1: fDTS = fPCLK
  *             @arg GTIM_CLOCKDIVISION_DIV2: fDTS = fPCLK / 2
  *             @arg GTIM_CLOCKDIVISION_DIV4: fDTS = fPCLK / 4
  */
#define HAL_GTIM_GET_CLOCKDIVISION(__HANDLE__)    ((__HANDLE__)->Instance->CR1 & GTIMx_CR1_CKD_Msk)

/**
  * @brief  在 GTIM 运行时获取输入捕获预分频
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: 获取 输入捕获1 的预分频值
  *             @arg GTIM_CHANNEL_2: 获取 输入捕获2 的预分频值
  *             @arg GTIM_CHANNEL_3: 获取 输入捕获3 的预分频值
  *             @arg GTIM_CHANNEL_4: 获取 输入捕获4 的预分频值
  * @retval 输入捕获预分频值为下列其一:
  *             @arg GTIM_ICPSC_DIV1: 每 1 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV2: 每 2 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV4: 每 4 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV8: 每 8 次事件捕获一次
  */
#define HAL_GTIM_GET_ICPRESCALER(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? (((__HANDLE__)->Instance->CCMR1CAP & GTIMx_CCMR1CAP_IC1PSC_Msk) >> 0U) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? (((__HANDLE__)->Instance->CCMR1CAP & GTIMx_CCMR1CAP_IC2PSC_Msk) >> 8U) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? (((__HANDLE__)->Instance->CCMR2CAP & GTIMx_CCMR2CAP_IC3PSC_Msk) >> 0U) : \
                                         (((__HANDLE__)->Instance->CCMR2CAP & GTIMx_CCMR2CAP_IC4PSC_Msk) >> 8U))

/**
  * @brief  在 GTIM 运行时设置 捕获/比较 寄存器值，而不调用另一个ConfigChannel函数
  * @param  __HANDLE__  GTIM 句柄指针.
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @param  __COMPARE__ 指定新的 捕获/比较 寄存器值
  * @retval None
  */
#define HAL_GTIM_SET_COMPARE(__HANDLE__, __CHANNEL__, __COMPARE__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCR1 = (__COMPARE__)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCR2 = (__COMPARE__)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCR3 = (__COMPARE__)) : \
                                         ((__HANDLE__)->Instance->CCR4 = (__COMPARE__)))

/**
  * @brief  在 GTIM 运行时获取 捕获/比较 寄存器值
  * @param  __HANDLE__ GTIM 句柄指针
  * @param  __CHANNEL__ 与 捕获/比较 寄存器相关联的GTIM通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: 获取 捕获/比较1 (CCR1) 寄存器值
  *             @arg GTIM_CHANNEL_2: 获取 捕获/比较2 (CCR2) 寄存器值
  *             @arg GTIM_CHANNEL_3: 获取 捕获/比较3 (CCR3) 寄存器值
  *             @arg GTIM_CHANNEL_4: 获取 捕获/比较4 (CCR4) 寄存器值
  * @retval 16-bit 的 捕获/比较 寄存器值 (CCRx)
  */
#define HAL_GTIM_GET_COMPARE(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCR1) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCR2) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCR3) : \
                                         ((__HANDLE__)->Instance->CCR4))

/**
  * @brief  使能 GTIM 输出比较 CCRx预装载
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @retval None
  */
#define HAL_GTIM_ENABLE_OCxPRELOAD(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CMP |= GTIMx_CCMR1CMP_OC1PE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CMP |= GTIMx_CCMR1CMP_OC2PE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CMP |= GTIMx_CCMR2CMP_OC3PE_Msk) : \
                                         ((__HANDLE__)->Instance->CCMR2CMP |= GTIMx_CCMR2CMP_OC4PE_Msk))

/**
  * @brief  禁止 GTIM 输出比较 CCRx预装载
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @retval None
  */
#define HAL_GTIM_DISABLE_OCxPRELOAD(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CMP &= ~GTIMx_CCMR1CMP_OC1PE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CMP &= ~GTIMx_CCMR1CMP_OC2PE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CMP &= ~GTIMx_CCMR2CMP_OC3PE_Msk) : \
                                         ((__HANDLE__)->Instance->CCMR2CMP &= ~GTIMx_CCMR2CMP_OC4PE_Msk))

/**
  * @brief  为指定通道启用快速模式(OCxFE)
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道， 该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @note   当启用快速模式时，触发器输入上的活动边缘就像CCx输出上的比较匹配一样。
  *             采样触发输入和激活CCx输出的延迟减少到3个时钟周期。
  * @note   仅适用于单脉冲模式
  * @retval None
  */
#define HAL_GTIM_ENABLE_OCxFAST(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CMP |= GTIMx_CCMR1CMP_OC1FE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CMP |= GTIMx_CCMR1CMP_OC2FE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CMP |= GTIMx_CCMR2CMP_OC3FE_Msk) : \
                                         ((__HANDLE__)->Instance->CCMR2CMP |= GTIMx_CCMR2CMP_OC4FE_Msk))

/**
  * @brief  为指定通道禁用快速模式(OCxFE)
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @note   当禁用快速模式时，CCx输出行为通常取决于计数器和CCRx值，
  *             即使触发器是打开的。当一个活动边缘发生在触发器输入上时，
  *             激活CCx输出的最小延迟是5个时钟周期。
  * @retval None
  */
#define HAL_GTIM_DISABLE_OCxFAST(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CMP &= ~GTIMx_CCMR1CMP_OC1FE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CMP &= ~GTIMx_CCMR1CMP_OC2FE_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CMP &= ~GTIMx_CCMR2CMP_OC3FE_Msk) : \
                                         ((__HANDLE__)->Instance->CCMR2CMP &= ~GTIMx_CCMR2CMP_OC4FE_Msk))

/**
  * @brief  置位 GTIMx_CR1 寄存器的更新请求源(URS)位。
  * @param  __HANDLE__ GTIM 句柄指针
  * @note   使能时，只有计数器上溢/下溢会生成更新中断或DMA请求(如果存在并且启用)
  * @retval None
  */
#define HAL_GTIM_URS_ENABLE(__HANDLE__)    ((__HANDLE__)->Instance->CR1 |= GTIMx_CR1_URS_Msk)

/**
  * @brief  重置 GTIMx_CR1 寄存器的更新请求源(URS)位。
  * @param  __HANDLE__ GTIM 句柄指针
  * @note   当 GTIMx_CR1 寄存器的URS位被重置时，下列任何事件都会产生一个更新中
  *         断或DMA请求(如果存在并且启用):
  *             _ 计数器上溢/下溢
  *             _ 将UG位置1
  *             _ 通过从模式控制器生成的更新事件
  * @retval None
  */
#define HAL_GTIM_URS_DISABLE(__HANDLE__)    ((__HANDLE__)->Instance->CR1 &=~ GTIMx_CR1_URS_Msk)

/**
  * @brief  辅助宏: 计算分频器的值，以达到所需的计数器时钟频率
  * @note   ex: @ref HAL_GTIM_CALC_PSC(80000000, 1000000);
  * @param  __TIMCLK__ 定时器输入时钟频率 (Hz)
  * @param  __CNTCLK__ 计数器时钟频率 (Hz)
  * @retval 预分频值 (Min_Data=0 ~ Max_Data=65535)
  */
#define HAL_GTIM_CALC_PSC(__TIMCLK__, __CNTCLK__) \
    ((__TIMCLK__) >= (__CNTCLK__)) ? (uint32_t)((__TIMCLK__)/(__CNTCLK__) - 1U) : 0U

/**
  * @brief  辅助宏: 计算自动重载值以达到所需的输出信号频率
  * @note   ex: @ref HAL_GTIM_CALC_PERIOD(1000000, 0, 10000);
  * @param  __TIMCLK__ 定时器输入时钟频率 (Hz)
  * @param  __PSC__    定时器分频值
  * @param  __FREQ__   输出信号频率 (Hz)
  * @retval  重载值 (Min_Data=0 ~ Max_Data=65535)
  */
#define HAL_GTIM_CALC_PERIOD(__TIMCLK__, __PSC__, __FREQ__) \
    (((__TIMCLK__)/((__PSC__) + 1U)) >= (__FREQ__)) ? ((__TIMCLK__)/((__FREQ__) * ((__PSC__) + 1U)) - 1U) : 0U

/**
  * @brief  辅助宏: 计算实现定时器输出所需的 active//inactive 延迟的比较值
  * @note   ex: @ref HAL_GTIM_CALC_PULSE(1000000, 0, 10);
  * @param  __TIMCLK__ 定时器输入时钟频率 (Hz)
  * @param  __PSC__    定时器分频值
  * @param  __DELAY__  定时器输出所需的 active/inactive 延迟 (us)
  * @retval 比较值 ( Min_Data=0 ~ Max_Data=65535)
  */
#define HAL_GTIM_CALC_PULSE(__TIMCLK__, __PSC__, __DELAY__) \
    ((uint32_t)(((uint64_t)(__TIMCLK__) * (uint64_t)(__DELAY__)) \
              / ((uint64_t)1000000U * (uint64_t)((__PSC__) + 1U))))

/**
  * @brief  辅助宏: 计算自动重载值以达到所需的脉冲持续时间(当定时器以单脉冲模式工作时)。
  * @note   ex: @ref HAL_GTIM_CALC_PERIOD_BY_DELAY(1000000, 0, 10, 20);
  * @param  __TIMCLK__ 定时器输入时钟频率 (Hz)
  * @param  __PSC__    定时器分频值
  * @param  __DELAY__  定时器输出所需的 active/inactive 延迟 (us)
  * @param  __PULSE__  脉冲持续时间 (us)
  * @retval 重载值 (Min_Data=0 ~ Max_Data=65535)
  */
#define HAL_GTIM_CALC_PERIOD_BY_DELAY(__TIMCLK__, __PSC__, __DELAY__, __PULSE__) \
    ((uint32_t)(HAL_GTIM_CALC_PULSE((__TIMCLK__), (__PSC__), (__PULSE__)) \
              + HAL_GTIM_CALC_PULSE((__TIMCLK__), (__PSC__), (__DELAY__))))

#define GTIM_SET_ICPRESCALERVALUE(__HANDLE__, __CHANNEL__, __ICPSC__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CAP |= ((__ICPSC__) << 0U)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CAP |= ((__ICPSC__) << 8U)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CAP |= ((__ICPSC__) << 0U)) : \
                                         ((__HANDLE__)->Instance->CCMR2CAP |= ((__ICPSC__) << 8U)))

#define GTIM_RESET_ICPRESCALERVALUE(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCMR1CAP &= ~GTIMx_CCMR1CAP_IC1PSC_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCMR1CAP &= ~GTIMx_CCMR1CAP_IC2PSC_Msk) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCMR2CAP &= ~GTIMx_CCMR2CAP_IC3PSC_Msk) : \
                                         ((__HANDLE__)->Instance->CCMR2CAP &= ~GTIMx_CCMR2CAP_IC4PSC_Msk))

#define GTIM_SET_CAPTUREPOLARITY(__HANDLE__, __CHANNEL__, __POLARITY__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCER |= ((__POLARITY__) << 0U))  : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCER |= ((__POLARITY__) << 4U))  : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCER |= ((__POLARITY__) << 8U))  : \
                                         ((__HANDLE__)->Instance->CCER |= ((__POLARITY__) << 12U)))

#define GTIM_RESET_CAPTUREPOLARITY(__HANDLE__, __CHANNEL__) \
    (((__CHANNEL__) == GTIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCER &= ~(GTIMx_CCER_CC1P_Msk | GTIMx_CCER_CC1NP_Msk)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCER &= ~(GTIMx_CCER_CC2P_Msk | GTIMx_CCER_CC2NP_Msk)) : \
     ((__CHANNEL__) == GTIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCER &= ~(GTIMx_CCER_CC3P_Msk | GTIMx_CCER_CC3NP_Msk)) : \
                                         ((__HANDLE__)->Instance->CCER &= ~(GTIMx_CCER_CC4P_Msk | GTIMx_CCER_CC4NP_Msk)))


/**
  * @brief  在 GTIM 运行时设置输入捕获预分频，而不调用HAL_GTIM_IC_ConfigChannel()函数
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @param  __ICPSC__ 指定输入捕获的预分频新值，该参数可为下列之一:
  *             @arg GTIM_ICPSC_DIV1: 每 1 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV2: 每 2 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV4: 每 4 次事件捕获一次
  *             @arg GTIM_ICPSC_DIV8: 每 8 次事件捕获一次
  * @retval None
  */
#define HAL_GTIM_SET_ICPRESCALER(__HANDLE__, __CHANNEL__, __ICPSC__)           \
    do                                                                         \
    {                                                                          \
        GTIM_RESET_ICPRESCALERVALUE((__HANDLE__), (__CHANNEL__));              \
        GTIM_SET_ICPRESCALERVALUE((__HANDLE__), (__CHANNEL__), (__ICPSC__));   \
    } while (0)

/**
  * @brief  在 GTIM 运行时设置 Capturex 输入极性。
  * @param  __HANDLE__  GTIM 句柄指针
  * @param  __CHANNEL__ 要配置的 GTIM 通道，该参数可为下列之一:
  *             @arg GTIM_CHANNEL_1: GTIM 通道 1
  *             @arg GTIM_CHANNEL_2: GTIM 通道 2
  *             @arg GTIM_CHANNEL_3: GTIM 通道 3
  *             @arg GTIM_CHANNEL_4: GTIM 通道 4
  * @param  __POLARITY__ TIx源的极性，该参数可为下列之一:
  *             @arg GTIM_INPUTCHANNELPOLARITY_RISING: 上升沿
  *             @arg GTIM_INPUTCHANNELPOLARITY_FALLING: 下降沿
  *             @arg GTIM_INPUTCHANNELPOLARITY_BOTHEDGE: 双边沿
  * @retval None
  */
#define HAL_GTIM_SET_CAPTUREPOLARITY(__HANDLE__, __CHANNEL__, __POLARITY__)    \
    do {                                                                       \
        GTIM_RESET_CAPTUREPOLARITY((__HANDLE__), (__CHANNEL__));               \
        GTIM_SET_CAPTUREPOLARITY((__HANDLE__), (__CHANNEL__), (__POLARITY__)); \
    } while (0)


/******************************************************************************/
/* Global function prototypes ('extern', definition in C source)              */
/******************************************************************************/
/* Time Base functions */
HAL_StatusTypeDef HAL_GTIM_Base_Init(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Base_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Base_Start(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Base_Stop(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Base_Start_IT(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Base_Stop_IT(GTIM_HandleTypeDef *htim);

/* Timer Output Compare functions */
HAL_StatusTypeDef HAL_GTIM_OC_Init(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_OC_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_OC_Start(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_OC_Stop(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_OC_Start_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_OC_Stop_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);

/* Timer PWM functions */
HAL_StatusTypeDef HAL_GTIM_PWM_Init(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_PWM_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_PWM_Start(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_PWM_Stop(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_PWM_Start_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_PWM_Stop_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);

/* Timer One Pulse functions */
HAL_StatusTypeDef HAL_GTIM_OnePulse_Init(GTIM_HandleTypeDef *htim, uint32_t OnePulseMode);
HAL_StatusTypeDef HAL_GTIM_OnePulse_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_OnePulse_Start(GTIM_HandleTypeDef *htim, uint32_t OutputChannel);
HAL_StatusTypeDef HAL_GTIM_OnePulse_Stop(GTIM_HandleTypeDef *htim, uint32_t OutputChannel);
HAL_StatusTypeDef HAL_GTIM_OnePulse_Start_IT(GTIM_HandleTypeDef *htim, uint32_t OutputChannel);
HAL_StatusTypeDef HAL_GTIM_OnePulse_Stop_IT(GTIM_HandleTypeDef *htim, uint32_t OutputChannel);

/* Timer Input Capture functions */
HAL_StatusTypeDef HAL_GTIM_IC_Init(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_IC_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_IC_Start(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_IC_Stop(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_IC_Start_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_IC_Stop_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);

/* Timer Encoder functions */
HAL_StatusTypeDef HAL_GTIM_Encoder_Init(GTIM_HandleTypeDef *htim,  GTIM_Encoder_InitTypeDef *sConfig);
HAL_StatusTypeDef HAL_GTIM_Encoder_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_Encoder_Start(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_Encoder_Stop(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_Encoder_Start_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_Encoder_Stop_IT(GTIM_HandleTypeDef *htim, uint32_t Channel);

/*  Timer Hall Sensor functions */
HAL_StatusTypeDef HAL_GTIM_HallSensor_Init(GTIM_HandleTypeDef *htim, GTIM_HallSensor_InitTypeDef *sConfig);
HAL_StatusTypeDef HAL_GTIM_HallSensor_DeInit(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_HallSensor_Start(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_HallSensor_Stop(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_HallSensor_Start_IT(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_HallSensor_Stop_IT(GTIM_HandleTypeDef *htim);

/* Control functions */
HAL_StatusTypeDef HAL_GTIM_OC_ConfigChannel(GTIM_HandleTypeDef *htim, GTIM_OC_InitTypeDef *sConfig, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_PWM_ConfigChannel(GTIM_HandleTypeDef *htim, GTIM_OC_InitTypeDef *sConfig, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_IC_ConfigChannel(GTIM_HandleTypeDef *htim, GTIM_IC_InitTypeDef *sConfig, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_OnePulse_ConfigChannel(GTIM_HandleTypeDef *htim, GTIM_OnePulse_InitTypeDef *sConfig,
                                                  uint32_t OutputChannel, uint32_t InputChannel);
HAL_StatusTypeDef HAL_GTIM_ConfigOCrefClear(GTIM_HandleTypeDef *htim, GTIM_ClearInputConfigTypeDef *sClearInputConfig,
                                            uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_ConfigClockSource(GTIM_HandleTypeDef *htim, GTIM_ClockConfigTypeDef *sClockSourceConfig);
HAL_StatusTypeDef HAL_GTIM_ConfigTI1Input(GTIM_HandleTypeDef *htim, uint32_t TI1_Selection);
HAL_StatusTypeDef HAL_GTIM_SlaveConfigSynchro(GTIM_HandleTypeDef *htim, GTIM_SlaveConfigTypeDef *sSlaveConfig);
HAL_StatusTypeDef HAL_GTIM_SlaveConfigSynchro_IT(GTIM_HandleTypeDef *htim, GTIM_SlaveConfigTypeDef *sSlaveConfig);
HAL_StatusTypeDef HAL_GTIM_GenerateEvent(GTIM_HandleTypeDef *htim, uint32_t EventSource);

/* Channel Captured value or state functions */
uint32_t HAL_GTIM_ReadCapturedValue(GTIM_HandleTypeDef *htim, uint32_t Channel);
HAL_GTIM_ActiveChannel HAL_GTIM_GetActiveChannel(GTIM_HandleTypeDef *htim);

/* Base functions */
void GTIM_Base_SetConfig(GTIM_TypeDef *TIMx, GTIM_Base_InitTypeDef *Structure);
void GTIM_ETR_SetConfig(GTIM_TypeDef *TIMx, uint32_t TIM_ExtTRGPrescaler, uint32_t TIM_ExtTRGPolarity, uint32_t ExtTRGFilter);
void GTIM_CCxChannelCmd(GTIM_TypeDef *TIMx, uint32_t Channel, uint32_t ChannelState);

/* Extended Control functions */
HAL_StatusTypeDef HAL_GTIM_MasterConfigSynchronization(GTIM_HandleTypeDef *htim, GTIM_MasterConfigTypeDef *sMasterConfig);
HAL_StatusTypeDef HAL_GTIM_ETRSelection(GTIM_HandleTypeDef *htim, uint32_t ETRSelection);
HAL_StatusTypeDef HAL_GTIM_RemapConfig(GTIM_HandleTypeDef *htim, uint32_t Remap);
HAL_StatusTypeDef HAL_GTIM_TISelection(GTIM_HandleTypeDef *htim, uint32_t TISelection, uint32_t Channel);
HAL_StatusTypeDef HAL_GTIM_ConfigSlaveModePreload(GTIM_HandleTypeDef *htim, uint32_t Source);
HAL_StatusTypeDef HAL_GTIM_EnableSlaveModePreload(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_DisableSlaveModePreload(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_ConfigEncoderIndex(GTIM_HandleTypeDef *htim, GTIM_EncoderIndexConfigTypeDef *sEncoderIndexConfig);
HAL_StatusTypeDef HAL_GTIM_EnableEncoderIndex(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_DisableEncoderIndex(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_EnableEncoderFirstIndex(GTIM_HandleTypeDef *htim);
HAL_StatusTypeDef HAL_GTIM_DisableEncoderFirstIndex(GTIM_HandleTypeDef *htim);

/* Interrupt Handler functions */
void HAL_GTIM_IRQHandler(GTIM_HandleTypeDef *htim);

/* Callback in non blocking modes (Interrupt) */
void HAL_GTIM_PeriodElapsedCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_OC_DelayElapsedCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_IC_CaptureCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_PWM_PulseFinishedCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_TriggerCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_ErrorCallback(GTIM_HandleTypeDef *htim);

/* Extended Callback */
void HAL_GTIM_EncoderIndexCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_DirectionChangeCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_IndexErrorCallback(GTIM_HandleTypeDef *htim);
void HAL_GTIM_TransitionErrorCallback(GTIM_HandleTypeDef *htim);


#ifdef __cplusplus
}
#endif

#endif /* __SYM32L010_HAL_GTIM_H */


/************************ (C) COPYRIGHT SIYIMicro *****END OF FILE*************/
